fix(redshift): terminate running queries when SQLMesh is interrupted - #6144

On Ctrl-C, SnapshotEvaluator.concurrent_context() recycles the adapter
before the context closes it. ThreadLocalConnectionPool.close_all() clears
every thread's attributes, so close() no longer found the backend PIDs of
queries still running on worker threads and left them running on Redshift.

RedshiftEngineAdapter now terminates running queries in both recycle() and
close(), before the pool is closed. If the calling thread was interrupted
mid-query or mid-transaction, its connection is closed and the sessions are
terminated from a new one.

Also removes the SIGTERM-to-SIGINT mapping in the CLI, which is deferred to
a follow-up so this change is scoped to Ctrl-C.

When the thread-local connection pools close another thread's connection
while it's in the middle of a transaction (e.g. when Ctrl-C recycles the
pool while workers are still running), they used to forget the
transaction. The worker's next statement then ran on a new connection in
a new transaction and could be committed without the statements that
were rolled back with the closed connection.

The transaction is now marked as broken instead. The worker's next
statement fails without opening a new connection, its rollback doesn't
touch the database, and committing it fails. Rollback also ends the
transaction now even if it fails.

When SQLMesh is interrupted (e.g. by Ctrl-C), worker threads aren't
waited for. A worker that hadn't started evaluating or creating a
snapshot yet would carry on after teardown on a new connection and run
the snapshot's statements anyway.

concurrent_context() now sets an event when it's interrupted, and
workers check it before a snapshot's non-transactional pre-statements
and before its main transaction. Work after the main transaction
commits isn't stopped, so the interval of committed data is still
recorded.